home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2001 May / SGI Freeware 2001 May - Disc 1.iso / dist / fw_kdelibs.idb / usr / freeware / kde / include / htmlobj.h.z / htmlobj.h
C/C++ Source or Header  |  1999-01-26  |  19KB  |  642 lines
  1. /* This file is part of the KDE libraries
  2.     Copyright (C) 1997 Martin Jones (mjones@kde.org)
  3.               (C) 1997 Torben Weis (weis@kde.org)
  4.  
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  9.  
  10.     This library is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.     Library General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU Library General Public License
  16.     along with this library; see the file COPYING.LIB.  If not, write to
  17.     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18.     Boston, MA 02111-1307, USA.
  19. */
  20. //-----------------------------------------------------------------------------
  21. //
  22. // KDE HTML Widget
  23.  
  24. #ifndef HTMLOBJ_H
  25. #define HTMLOBJ_H
  26.  
  27. #include <stdio.h>
  28.  
  29. #include <qpainter.h>
  30. #include <qlist.h>
  31. #include <qstrlist.h>
  32. #include <qarray.h>
  33. #include <qpixmap.h>
  34. #include <qstack.h>
  35. #include <qfont.h>
  36. #include <qtimer.h>
  37.  
  38. class QMovie;
  39.  
  40. #define USE_QMOVIE
  41.  
  42. #include <kurl.h>
  43.  
  44. class HTMLClueV;
  45. class HTMLImage;
  46. class HTMLClue;
  47. class HTMLClueFlow;
  48. class HTMLClueAligned;
  49. class KHTMLWidget;
  50.  
  51. #include "htmlfont.h"
  52.  
  53. class HTMLCell;
  54.  
  55. /**
  56.  * Used by @ref HTMLObject::findCells
  57.  */
  58. struct HTMLCellInfo
  59. {
  60. public:
  61.   HTMLCell *pCell;
  62.   int xAbs;
  63.   int baseAbs;
  64.   int tx;
  65.   int ty;
  66. };
  67.  
  68. class HTMLAnchor;
  69.  
  70. //-----------------------------------------------------------------------------
  71. // HTMLObject is the base class for all HTML objects.
  72. //
  73. class HTMLObject
  74. {
  75. public:
  76.     HTMLObject();
  77.     virtual ~HTMLObject() { objCount--; }
  78.  
  79.     enum VAlign { Top, Bottom, VCenter, VNone };
  80.     enum HAlign { Left, HCenter, Right, HNone };
  81.  
  82.     /*
  83.      * This function should cause the HTMLObject to calculate its
  84.      * width and height.
  85.      */
  86.     virtual void calcSize( HTMLClue * = 0L ) { }
  87.     
  88.     /*
  89.      * This function forces a size calculation for objects which
  90.      * calculate their size at construction.  This is useful if
  91.      * the metrics of the painter change, e.g. if the html is to
  92.      * be printed on a printer instead of the display.
  93.      */
  94.     virtual void recalcBaseSize( QPainter * ) { }
  95.  
  96.     /*
  97.      * This function calculates the minimum width that the object
  98.      * can be set to. (added for table support)
  99.      */
  100.     virtual int  calcMinWidth() { return width; }
  101.  
  102.     /*
  103.      * This function calculates the width that the object would like
  104.      * to be. (added for table support)
  105.      */
  106.     virtual int  calcPreferredWidth() { return width; }
  107.  
  108.     virtual void setMaxAscent( int ) { }
  109.     virtual void setMaxWidth( int _w ) { max_width = _w; }
  110.     virtual int  findPageBreak( int _y );
  111.  
  112.     /*
  113.      * Print the object but only if it fits in the rectangle given
  114.      * by _x,_y,_width,_ascender. (_x|_y) is the lower left corner relative
  115.      * to the parent of this object ( usually HTMLClue ).
  116.      */
  117.     virtual bool print( QPainter *, int, int, int, int, int, int, bool )
  118.     { return false; }
  119.  
  120.     virtual void print( QPainter *, HTMLObject *, int, int, int, int, int, int )
  121.     {}
  122.     /*
  123.      * Print the object.
  124.      */
  125.     virtual void print( QPainter *, int, int ) { }
  126.  
  127.     virtual HTMLObject *checkPoint( int, int );
  128.     virtual HTMLObject *mouseEvent( int, int, int, int ) { return 0; }
  129.     virtual void selectByURL(QPainter *, const char *, bool, int _tx, int _ty);
  130.     virtual void select( QPainter *, bool, int _tx, int _ty );
  131.  
  132.     /*
  133.      * Selects the object if it is inside the rectangle and deselects it
  134.      * otherwise.
  135.      */
  136.     virtual void select( QPainter *, QRect &_rect, int _tx, int _ty );
  137.  
  138.     // Select all objects matching the regular expression.
  139.     virtual void select( QPainter *_painter, QRegExp& _pattern, bool _select,
  140.     int _tx, int _ty );
  141.  
  142.     virtual void select( bool _s ) { setSelected( _s ); }
  143.  
  144.     // select text.  returns whether any text was selected.
  145.     virtual bool selectText( QPainter *_painter, int _x1, int _y1,
  146.     int _x2, int _y2, int _tx, int _ty );
  147.  
  148.     virtual void getSelected( QStrList & );
  149.     virtual void getSelectedText( QString & ) {}
  150.  
  151.     /*
  152.      * Some objects may need to know their absolute position on the page.
  153.      */
  154.     virtual void calcAbsolutePos( int, int ) { }
  155.  
  156.     virtual int  getAbsX() { return -1; }
  157.     virtual int  getAbsY() { return -1; }
  158.  
  159.     virtual void reset() { setPrinted( false ); }
  160.  
  161.     /********************************
  162.      * These two functions are overloaded by objects that need to have a remote
  163.      * file downloaded, e.g. HTMLImage.
  164.      *
  165.      * fileLoaded is called when the requested file has arrived.
  166.      */
  167.     virtual void fileLoaded( const char * /* _filename */ ) { }
  168.  
  169.     /*
  170.      * returns the url of the file that has been requested.
  171.      */
  172.     virtual const char *requestedFile() { return 0; }
  173.  
  174.     enum ObjectType { Object, Clue };
  175.  
  176.     /*
  177.      * sometimes a clue would like to know if an object is a 
  178.      * clue or a basic object.
  179.      */
  180.     virtual ObjectType getObjectType() const
  181.         {    return Object; }
  182.  
  183.     /*
  184.      * Get X-Position of this object relative to its parent
  185.      */
  186.     int getXPos() const { return x; }
  187.  
  188.     /*
  189.      * Get Y-Position of this object relative to its parent
  190.      */
  191.     int getYPos() const { return y; }
  192.  
  193.     int getWidth() const { return width; }
  194.     int getHeight() const { return ascent+descent; }
  195.     int getAscent() const { return ascent; }
  196.     int getDescent() const { return descent; }
  197.     int getMaxWidth() const { return max_width; }
  198.     int getPercent() const { return percent; }
  199.  
  200.     /*
  201.      * return the URL associated with this object if available, else 0.
  202.      */
  203.     virtual const char* getURL() const { return 0; }
  204.     virtual const char* getTarget() const { return 0; }
  205.  
  206.     void setPos( int _x, int _y ) { y=_y; x=_x; }
  207.     void setXPos( int _x ) { x=_x; }
  208.     void setYPos( int _y ) { y=_y; }
  209.  
  210.     enum ObjectFlags { Separator = 0x01, NewLine = 0x02, Selected = 0x04,
  211.             FixedWidth = 0x08, Aligned = 0x10,
  212.             Printed = 0x20 };
  213.  
  214.     bool isSeparator() const { return flags & Separator; }
  215.     bool isNewline() const { return flags & NewLine; }
  216.     bool isSelected() const { return flags & Selected; }
  217.     bool isFixedWidth() const { return flags & FixedWidth; }
  218.     bool isAligned() const { return flags & Aligned; }
  219.     bool isPrinted() const { return flags & Printed; }
  220.     
  221.     void setSeparator( bool s ) { s ? flags|=Separator : flags&=~Separator; }
  222.     void setNewline( bool n ) { n ? flags|=NewLine : flags&=~NewLine; }
  223.     void setSelected( bool s ) { s ? flags|=Selected : flags&=~Selected; }
  224.     void setFixedWidth( bool f ) { f ? flags|=FixedWidth : flags&=~FixedWidth; }
  225.     void setAligned( bool a ) { a ? flags|=Aligned : flags&=~Aligned; }
  226.     void setPrinted( bool p ) { p ? flags|=Printed : flags&=~Printed; }
  227.     
  228.     /*
  229.      * Searches in all children ( and tests itself ) for an HTMLAnchor object
  230.      * with the name '_name'. Returns 0L if the anchor could not be found.
  231.      * '_point' is modified so that it holds the position of the anchor relative
  232.      * to the parent.
  233.      */
  234.     virtual HTMLAnchor* findAnchor( const char */*_name*/, QPoint */*_point*/ )
  235.             { return 0L; }
  236.  
  237.     /*
  238.      * All objects can be an element in a list and maintain a pointer to
  239.      * the next object.
  240.      */
  241.     void setNext( HTMLObject *n ) { nextObj = n; }
  242.     HTMLObject *next() const { return nextObj; }
  243.  
  244.     void printCount() { printf( "Object count: %d\n", objCount ); }
  245.  
  246.     virtual void findCells( int, int, QList<HTMLCellInfo> & ) { }
  247.  
  248. protected:
  249.     int x;
  250.     int y;
  251.     int ascent;
  252.     int descent;
  253.     short width;
  254.     short max_width;
  255.     // percent stuff added for table support
  256.     short percent;    // width = max_width * percent / 100
  257.     unsigned char flags;
  258.     HTMLObject *nextObj;
  259.     static int objCount;
  260. };
  261.  
  262. //-----------------------------------------------------------------------------
  263.  
  264. class HTMLText : public HTMLObject
  265. {
  266. public:
  267.     HTMLText( const char*, const HTMLFont *, QPainter * ,bool _autoDelete=FALSE);
  268.     HTMLText( const HTMLFont *, QPainter * );
  269.     virtual ~HTMLText() { if (autoDelete) delete [] text; }
  270.  
  271.     virtual bool selectText( QPainter *_painter, int _x1, int _y1,
  272.     int _x2, int _y2, int _tx, int _ty );
  273.     virtual void getSelectedText( QString & );
  274.     virtual void recalcBaseSize( QPainter *_painter );
  275.     virtual bool print( QPainter *_painter, int _x, int _y, int _width,
  276.         int _height, int _tx, int _ty, bool toPrinter );
  277.     virtual void print( QPainter *, int _tx, int _ty );
  278.  
  279. protected:
  280.     int getCharIndex( QPainter *_painter, int _xpos );
  281.  
  282. protected:
  283.     const char* text;
  284.     const HTMLFont *font;
  285.     // This is a rediculous waste of memory, but I can't think of another
  286.     // way at the moment.
  287.     short selStart;
  288.     short selEnd;
  289.     bool autoDelete;
  290. };
  291.  
  292. //-----------------------------------------------------------------------------
  293. //
  294. // This object is text which also has an associated link.  This data is
  295. // not maintained in HTMLText to conserve memory.
  296. //
  297. class HTMLLinkText : public HTMLText
  298. {
  299. public:
  300.     HTMLLinkText( const char*_str, const HTMLFont *_font, QPainter *_painter,
  301.         char *_url, const char *_target, bool _autoDelete=FALSE )
  302.     : HTMLText( _str, _font, _painter,_autoDelete )
  303.         { url = _url; target = _target; }
  304.     virtual ~HTMLLinkText() { }
  305.  
  306.     virtual const char* getURL() const { return url; }
  307.     virtual const char* getTarget() const { return target; }
  308.  
  309. protected:
  310.     char *url;
  311.     const char *target;
  312. };
  313.  
  314. //-----------------------------------------------------------------------------
  315.  
  316. class HTMLRule : public HTMLObject
  317. {
  318. public:
  319.     HTMLRule( int _max_width, int _percent, int _size=1, bool _shade=TRUE );
  320.  
  321.     virtual int  calcMinWidth();
  322.     virtual int  calcPreferredWidth() { return calcMinWidth(); }
  323.     virtual void setMaxWidth( int );
  324.     virtual bool print( QPainter *_painter, int _x, int _y, int _width,
  325.     int _height, int _tx, int _ty, bool toPrinter );
  326.     virtual void print( QPainter *, int _tx, int _ty );
  327.  
  328. protected:
  329.     bool shade;
  330. };
  331.  
  332. //-----------------------------------------------------------------------------
  333.  
  334. class HTMLBullet : public HTMLObject
  335. {
  336. public:
  337.     HTMLBullet( int _height, int _level, const QColor &col );
  338.     virtual ~HTMLBullet() { }
  339.  
  340.     virtual bool print( QPainter *_painter, int _x, int _y, int _width,
  341.     int _height, int _tx, int _ty, bool toPrinter );
  342.     virtual void print( QPainter *, int _tx, int _ty );
  343.  
  344. protected:
  345.     char level;
  346.     QColor color;
  347. };
  348.  
  349. //-----------------------------------------------------------------------------
  350.  
  351. class HTMLVSpace : public HTMLObject
  352. {
  353. public:
  354.     enum Clear { CNone, Left, Right, All };
  355.  
  356.     HTMLVSpace( int _vspace, Clear c = CNone );
  357.     virtual ~HTMLVSpace() { }
  358.  
  359.     virtual void getSelectedText( QString & );
  360.  
  361.     Clear clear()
  362.     { return cl; }
  363.  
  364. private:
  365.     Clear cl;
  366. };
  367.  
  368. //-----------------------------------------------------------------------------
  369. // This class is inserted everywhere where a <a name="anchor">
  370. // appears.
  371. //
  372. class HTMLAnchor : public HTMLObject
  373. {
  374. public:
  375.     HTMLAnchor( const char *_name ) : name( _name ) {}
  376.     virtual ~HTMLAnchor() { }
  377.  
  378.     const char* getName() { return name; }
  379.  
  380.     virtual void setMaxAscent( int _a );
  381.     virtual HTMLAnchor* findAnchor( const char *_name, QPoint *_p );
  382.  
  383. protected:
  384.     QString name;
  385. };
  386.  
  387. //-----------------------------------------------------------------------------
  388.  
  389. class HTMLCachedImage
  390. {
  391. public:
  392.     HTMLCachedImage( const char * );
  393.     virtual ~HTMLCachedImage() { }
  394.  
  395.     QPixmap* getPixmap() { return pixmap; }
  396.     const char *getFileName() { return filename.data(); }
  397.  
  398. protected:
  399.     QPixmap *pixmap;
  400.     QString filename;
  401. };
  402.  
  403. //-----------------------------------------------------------------------------
  404.  
  405. class HTMLImage : public QObject, public HTMLObject
  406. {
  407.     Q_OBJECT
  408. public:
  409.     HTMLImage( KHTMLWidget *widget, const char *, char *_url,
  410.         char *_target, int _max_width, int _width = -1,
  411.         int _height = -1, int _percent = 0, int bdr = 0 );
  412.     virtual ~HTMLImage();
  413.  
  414.     virtual int  calcMinWidth();
  415.     virtual int  calcPreferredWidth();
  416.     virtual void setMaxWidth( int );
  417.     virtual void select( QPainter *, bool, int _tx, int _ty );
  418.     virtual bool print( QPainter *_painter, int _x, int _y, int _width,
  419.     int _height, int _tx, int _ty, bool toPrinter );
  420.     virtual void print( QPainter *, int _tx, int _ty );
  421.  
  422.     virtual void calcAbsolutePos( int _x, int _y );
  423.     virtual int  getAbsX();
  424.     virtual int  getAbsY();
  425.  
  426.     void setOverlay( const char *ol );
  427.  
  428.     static void cacheImage( const char * );
  429.     static QPixmap* findImage( const char * );
  430.  
  431.     /* Tells the object the the requested image is available
  432.      *
  433.      * The image is on the local disk in the file named '_filename.'
  434.      */
  435.     virtual void fileLoaded( const char *_filename );
  436.     virtual const char *requestedFile()
  437.            {    return imageURL.data(); }
  438.  
  439.     virtual const char* getURL() const { return url; }
  440.     virtual const char* getTarget() const { return target; }
  441.  
  442.     void setBorderColor( const QColor &color )
  443.     {   borderColor = color; }
  444.  
  445. protected slots:
  446.     void movieUpdated( const QRect &rect );
  447.  
  448. protected:
  449.  
  450.     /*
  451.      * Calculates the size of the loaded image.
  452.      * This function is usually called from the constructor or from
  453.      * 'imageLoaded'.
  454.      */
  455.     void init();
  456.     
  457.     /*
  458.      * Pointer to the image
  459.      * If this pointer is 0L, that means that the picture could not be loaded
  460.      * for some strange reason or that the image is waiting to be downloaded
  461.      * from the internet for example.
  462.      */
  463.     QPixmap *pixmap;
  464.  
  465. #ifdef USE_QMOVIE
  466.     QMovie *movie;
  467. #else
  468.     void *movie;
  469. #endif
  470.  
  471.     // this image is overlaid on top of the image.
  472.     // Used by HTML widget to show links/read only files, etc.
  473.     QPixmap *overlay;
  474.  
  475.     /*
  476.      * The URL of this image.
  477.      * This variable is only used if we have to wait for the image.
  478.      * Otherwise this string will be empty.
  479.      */
  480.     QString imageURL;
  481.     
  482.     KHTMLWidget *htmlWidget;
  483.     
  484.     static QList<HTMLCachedImage>* pCache;
  485.  
  486.     /*
  487.      * Flag telling wether this image was found in the cache
  488.      * If this flag is set, you may not delete the pixmap since the pixmap
  489.      * belongs to the HTMLCachedImage.
  490.      */
  491.     bool cached;
  492.  
  493.     /*
  494.      * If we knew the size of the image from the <img width=...> tag then this
  495.      * flag is TRUE.
  496.      * We need this flag if the image has to be loaded from the web. In this
  497.      * case we may have to reparse the HTML code if we did not know the size
  498.      * during the first parsing.
  499.      */
  500.     bool predefinedWidth;
  501.  
  502.     /*
  503.      * If we knew the size of the image from the <img height=...> tag then
  504.      * this flag is TRUE.
  505.      * We need this flag if the image has to be loaded from the web. In this
  506.      * case we may have to reparse the HTML code if we did not know the size
  507.      * during the first parsing.
  508.      */
  509.     bool predefinedHeight;
  510.  
  511.     /*
  512.      * Tells the function 'imageLoaded' wether it runs synchronized with the
  513.      * constructor
  514.      * If an image has to be loaded from the net, it may happen that the image
  515.      * is cached.  This means the the function 'imageLoaded' is called before
  516.      * the control returns to the constructor, since the constructor requested
  517.      * the image and this caused in turn 'imageLoaded' to be called. In this
  518.      * case the images arrived just in time and no repaint or recalculate
  519.      * action must take place. If 'imageLoaded' works synchron with
  520.      * the constructor then this flag is set to TRUE.
  521.      */
  522.     bool synchron;
  523.  
  524.     // border width
  525.     int border;
  526.  
  527.     QColor borderColor;
  528.  
  529.     char *url;
  530.     char *target;
  531.  
  532.     // The absolute position of this object on the page
  533.     int absX;
  534.     int absY;
  535. };
  536.  
  537. //----------------------------------------------------------------------------
  538. /*
  539.  * HTMLArea holds an area as specified by the <AREA > tag.
  540.  */
  541. class HTMLArea
  542. {
  543. public:
  544.     HTMLArea( const QPointArray &_points, const char *_url,
  545.         const char *_target = 0 );
  546.     HTMLArea( const QRect &_rect, const char *_url, const char *_target = 0 );
  547.     HTMLArea( int _x, int _y, int _r, const char *_url,
  548.         const char *_target = 0 );
  549.  
  550.     enum Shape { Poly, Rect, Circle };
  551.  
  552.     bool contains( const QPoint &_point ) const
  553.         {    return region.contains( _point ); }
  554.  
  555.     const QString &getURL() const
  556.         {    return url; }
  557.     const char *getTarget() const
  558.         {    return target; }
  559.  
  560. protected:
  561.     QRegion region;
  562.     QString url;
  563.     QString target;
  564. };
  565.  
  566. //----------------------------------------------------------------------------
  567.  
  568. /*
  569.  * HTMLMap contains a list of areas in the image map.
  570.  * i.e. all areas between <MAP > </MAP>
  571.  * This object is derived from HTMLObject so that it can make use of
  572.  * URLLoaded().
  573.  */
  574. class HTMLMap : public HTMLObject
  575. {
  576. public:
  577.     HTMLMap( KHTMLWidget *w, const char *_url );
  578.     virtual ~HTMLMap();
  579.  
  580.     virtual void fileLoaded( const char *_filename );
  581.     virtual const char *requestedFile()
  582.         {    return mapurl; }
  583.  
  584.     void addArea( HTMLArea *_area )
  585.         {    areas.append( _area ); }
  586.     const HTMLArea *containsPoint( int, int );
  587.  
  588.     const char *mapURL() const
  589.         {    return mapurl; }
  590.  
  591. protected:
  592.     QList<HTMLArea> areas;
  593.     KHTMLWidget *htmlWidget;
  594.     QString mapurl;
  595. };
  596.  
  597. //----------------------------------------------------------------------------
  598.  
  599. class HTMLImageMap : public HTMLImage
  600. {
  601. public:
  602.     HTMLImageMap( KHTMLWidget *widget, const char*, char *_url,
  603.         char *_target, int _max_width, int _width = -1,
  604.         int _height = -1, int _percent = 0, int brd = 0 );
  605.     virtual ~HTMLImageMap() {}
  606.  
  607.     virtual HTMLObject* checkPoint( int, int );
  608.  
  609.     void setMapURL( const char *_url )
  610.         {    mapurl = _url; }
  611.     const QString& mapURL() const
  612.         {    return mapurl; }
  613.  
  614.     enum Type { ClientSide, ServerSide };
  615.  
  616.     void setMapType( Type t )
  617.         {    type = t; }
  618.     bool mapType() const
  619.         {    return type; }
  620.  
  621. protected:
  622.     /*
  623.      * The URL set by <a href=...><img ... ISMAP></a> for server side maps
  624.      */
  625.     QString serverurl;
  626.  
  627.     /*
  628.      * The URL set by <img ... USEMAP=mapurl> for client side maps
  629.      */
  630.     QString mapurl;
  631.  
  632.     /*
  633.      * ClientSide or ServerSide
  634.      */
  635.     Type type;
  636. };
  637.  
  638. //----------------------------------------------------------------------------
  639.  
  640. #endif // HTMLOBJ
  641.  
  642.